import { NextRequest, NextResponse } from 'next/server'
import { createServerSupabaseClient } from '@/lib/supabase'
export async function GET(
request: NextRequest,
{ params }: { params: { id: string } }
) {
try {
const supabase = createServerSupabaseClient()
const bookId = params.id
// Get current user session
const authHeader = request.headers.get('authorization')
let user
try {
if (authHeader) {
const { data: { user: authUser }, error: authError } = await supabase.auth.getUser(authHeader.replace('Bearer ', ''))
if (!authError) user = authUser
} else {
const { data: { user: sessionUser }, error: sessionError } = await supabase.auth.getUser()
if (!sessionError) user = sessionUser
}
} catch (e) {
// Ignore auth errors
}
if (!user) {
return NextResponse.json(
{ error: 'Authentication required' },
{ status: 401 }
)
}
// Get GitHub integration
const { data: profile } = await supabase
.from('profiles')
.select('github_integrations')
.eq('id', user.id)
.single()
const integration = profile?.github_integrations?.[bookId]
if (!integration) {
return NextResponse.json(
{ error: 'GitHub integration not found' },
{ status: 404 }
)
}
// Get files from GitHub repository
const owner = integration.github_username
const repo = integration.repository_name
const accessToken = integration.access_token
try {
// First, get the latest commit SHA to ensure we're comparing against the latest version
const latestCommit = await getLatestCommit(owner, repo, accessToken)
if (!latestCommit) {
console.log('📊 GitHub Compare API: No commits found - repository is empty')
return NextResponse.json({
committedFiles: {},
repositoryEmpty: true
})
}
console.log('📊 GitHub Compare API: Latest commit:', latestCommit.sha)
// Get repository contents using the tree API for better performance
const committedFiles = await getRepositoryFilesFromTree(owner, repo, accessToken, latestCommit.sha)
console.log('📊 GitHub Compare API: Found committed files:', Object.keys(committedFiles).length)
console.log('📊 GitHub Compare API: File paths:', Object.keys(committedFiles))
return NextResponse.json({
committedFiles,
latestCommitSha: latestCommit.sha,
repositoryEmpty: false
})
} catch (githubError) {
console.error('❌ GitHub Compare API: Error fetching files:', githubError)
// Check if it's a 409 error (empty repository)
if (githubError instanceof Error && githubError.message.includes('409')) {
console.log('📊 GitHub Compare API: Repository is empty')
return NextResponse.json({
committedFiles: {},
repositoryEmpty: true
})
}
return NextResponse.json(
{ error: 'Failed to fetch files from GitHub', details: githubError instanceof Error ? githubError.message : String(githubError) },
{ status: 500 }
)
}
} catch (error) {
return NextResponse.json(
{ error: 'Internal server error' },
{ status: 500 }
)
}
}
// Helper function to get the latest commit
async function getLatestCommit(owner: string, repo: string, accessToken: string): Promise<{ sha: string; commit: any } | null> {
try {
const url = `https://api.github.com/repos/${owner}/${repo}/commits/HEAD`
console.log(`📊 GitHub Compare API: Fetching latest commit from ${url}`)
const response = await fetch(url, {
headers: {
'Authorization': `Bearer ${accessToken}`,
'Accept': 'application/vnd.github.v3+json'
}
})
if (!response.ok) {
if (response.status === 409) {
// Repository is empty
return null
}
throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
}
return await response.json()
} catch (error) {
console.error('❌ GitHub Compare API: Error fetching latest commit:', error)
throw error
}
}
// More efficient function using GitHub's tree API
async function getRepositoryFilesFromTree(owner: string, repo: string, accessToken: string, commitSha: string): Promise<{ [path: string]: string }> {
const files: { [path: string]: string } = {}
try {
// Get the tree for the commit (recursive to get all files)
const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${commitSha}?recursive=1`
console.log(`📊 GitHub Compare API: Fetching tree from ${treeUrl}`)
const treeResponse = await fetch(treeUrl, {
headers: {
'Authorization': `Bearer ${accessToken}`,
'Accept': 'application/vnd.github.v3+json'
}
})
if (!treeResponse.ok) {
throw new Error(`GitHub Tree API error: ${treeResponse.status} ${treeResponse.statusText}`)
}
const treeData = await treeResponse.json()
console.log(`📊 GitHub Compare API: Found ${treeData.tree.length} items in tree`)
// Filter for files only (not directories) and exclude README.md
const fileItems = treeData.tree.filter((item: any) =>
item.type === 'blob' &&
item.path !== 'README.md' &&
!item.path.startsWith('.git')
)
console.log(`📊 GitHub Compare API: Processing ${fileItems.length} files`)
// Fetch file contents in batches to avoid rate limiting
const batchSize = 10
for (let i = 0; i < fileItems.length; i += batchSize) {
const batch = fileItems.slice(i, i + batchSize)
await Promise.all(batch.map(async (item: any) => {
try {
// Use the blob API to get file content by SHA
const blobUrl = `https://api.github.com/repos/${owner}/${repo}/git/blobs/${item.sha}`
const blobResponse = await fetch(blobUrl, {
headers: {
'Authorization': `Bearer ${accessToken}`,
'Accept': 'application/vnd.github.v3+json'
}
})
if (blobResponse.ok) {
const blobData = await blobResponse.json()
// GitHub returns content as base64 if it's binary or large
let content = ''
if (blobData.encoding === 'base64') {
try {
content = Buffer.from(blobData.content, 'base64').toString('utf-8')
} catch {
// Skip binary files
console.log(`📊 GitHub Compare API: Skipping binary file ${item.path}`)
return
}
} else {
content = blobData.content
}
// Normalize file path to match BookWiz format
const normalizedPath = normalizeFilePath(item.path)
files[normalizedPath] = content
console.log(`📊 GitHub Compare API: Retrieved content for ${normalizedPath} (${content.length} chars)`)
} else {
console.error(`❌ GitHub Compare API: Failed to fetch blob for ${item.path}:`, blobResponse.status)
}
} catch (fileError) {
console.error(`❌ GitHub Compare API: Error fetching file ${item.path}:`, fileError)
}
}))
}
} catch (error) {
console.error(`❌ GitHub Compare API: Error in getRepositoryFilesFromTree:`, error)
throw error
}
return files
}
// Helper function to normalize file paths to match BookWiz format
function normalizeFilePath(githubPath: string): string {
// Remove any leading slashes and normalize the path
const normalized = githubPath.replace(/^\/+/, '')
// If the file is directly in the root, just return the filename
// This matches how BookWiz stores file paths
const parts = normalized.split('/')
if (parts.length === 1) {
return parts[0]
}
// For nested files, return the full path
return normalized
}
// Keep the old function as fallback if needed
async function getRepositoryFiles(owner: string, repo: string, accessToken: string, path: string = ''): Promise<{ [path: string]: string }> {
const files: { [path: string]: string } = {}
try {
const url = `https://api.github.com/repos/${owner}/${repo}/contents${path ? `/${path}` : ''}`
console.log(`📊 GitHub Compare API: Fetching ${url}`)
const response = await fetch(url, {
headers: {
'Authorization': `Bearer ${accessToken}`,
'Accept': 'application/vnd.github.v3+json'
}
})
if (!response.ok) {
if (response.status === 404) {
// Repository might be empty or path doesn't exist
console.log(`📊 GitHub Compare API: Path not found (404): ${path || 'root'}`)
return files
}
console.error(`❌ GitHub Compare API: GitHub API error for ${url}:`, response.status, response.statusText)
throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
}
const contents = await response.json()
// Handle single file vs array of files
const items = Array.isArray(contents) ? contents : [contents]
console.log(`📊 GitHub Compare API: Found ${items.length} items in ${path || 'root'}`)
for (const item of items) {
if (item.type === 'file' && item.name !== 'README.md') {
try {
// Get file content
const fileResponse = await fetch(item.download_url, {
headers: {
'Authorization': `Bearer ${accessToken}`
}
})
if (fileResponse.ok) {
const content = await fileResponse.text()
const filePath = path ? `${path}/${item.name}` : item.name
files[filePath] = content
console.log(`📊 GitHub Compare API: Retrieved content for ${filePath} (${content.length} chars)`)
} else {
console.error(`❌ GitHub Compare API: Failed to fetch content for ${item.name}:`, fileResponse.status)
}
} catch (fileError) {
console.error(`❌ GitHub Compare API: Error fetching file ${item.name}:`, fileError)
}
} else if (item.type === 'dir') {
// Recursively get directory contents
const dirPath = path ? `${path}/${item.name}` : item.name
console.log(`📊 GitHub Compare API: Entering directory ${dirPath}`)
const dirFiles = await getRepositoryFiles(owner, repo, accessToken, dirPath)
Object.assign(files, dirFiles)
}
}
} catch (error) {
console.error(`❌ GitHub Compare API: Error in getRepositoryFiles for path ${path}:`, error)
throw error // Re-throw instead of silently handling
}
return files
}